home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1998 June / SGI Freeware 1998 June.iso / dist / fw_ATxgopher.idb / usr / freeware / src / xgopher.1.3 / bkmkfile.c.z / bkmkfile.c
C/C++ Source or Header  |  1998-01-21  |  8KB  |  318 lines
  1. /* bkmkfile.c
  2.    Procedures to save and restore bookmarks between Xgopher sessions. */
  3.  
  4.      /*---------------------------------------------------------------*/
  5.      /* Xgopher        version 1.3     08 April 1993                  */
  6.      /*                version 1.2     20 November 1992               */
  7.      /*                version 1.1     20 April 1992                  */
  8.      /*                version 1.0     04 March 1992                  */
  9.      /* X window system client for the University of Minnesota        */
  10.      /*                                Internet Gopher System.        */
  11.      /* Allan Tuchman, University of Illinois at Urbana-Champaign     */
  12.      /*                Computing and Communications Services Office   */
  13.      /* Copyright 1992, 1993 by                                       */
  14.      /*           the Board of Trustees of the University of Illinois */
  15.      /* Permission is granted to freely copy and redistribute this    */
  16.      /* software with the copyright notice intact.                    */
  17.      /*---------------------------------------------------------------*/
  18.  
  19.  
  20. /* Some attempt has been made to make this compatable with the bookmark
  21.    save file used by the curses client.  I can maintain this compatability
  22.    as long as the other client doesn't change too much or too often. */
  23.  
  24. #include <stdio.h>
  25.  
  26. #include "bkmkfile.h"
  27. #include "conf.h"
  28. #include "osdep.h"
  29. #include "markList.h"
  30. #include "gui.h"
  31. #include "misc.h"
  32. #include "util.h"
  33.  
  34. #include <pwd.h>
  35. #include <string.h>
  36. #include <sys/types.h>
  37. #include <errno.h>
  38.  
  39.  
  40.     /* In deference to the curses client, we'll attempt to save the
  41.        resources that are stored in this file that really don't belong
  42.        there. */
  43.  
  44. static char    userStuff[USER_STUFF_LEN];
  45.  
  46.     /* saved status values */
  47.  
  48. static char    bookmarkFilename[PATH_NAME_LEN] = "";
  49. static BOOLEAN    appendBkmkList = TRUE;
  50.  
  51.  
  52. /* setBmkmFile
  53.    Store the name of the bookmark file.  This is initially set by
  54.    resources or defaults, then may be changed by user option. */
  55.  
  56. void
  57. setBkmkFile(fn)
  58. char    *fn;
  59. {
  60.     strncpy(bookmarkFilename, tildePath(fn), PATH_NAME_LEN);
  61. }
  62.  
  63.  
  64. /* setBmkmAppend
  65.    Store the status of the flag that says whether to replace a bookmark
  66.    list when it is read in or to append the bookmark list to existing. */
  67.  
  68. void
  69. setBkmkAppend(appendFlag)
  70. BOOLEAN    appendFlag;
  71. {
  72.     appendBkmkList = appendFlag;
  73. }
  74.  
  75.  
  76. /* bkmkOpen
  77.    return a (possibly invalid) file descriptor of an open bookmark file */
  78.  
  79. int
  80. bkmkOpen(flags)
  81. int    flags;
  82. {
  83.     struct passwd    *pwdentry;
  84.     char        bkmkFile[PATH_NAME_LEN];
  85.     int        bFD;
  86.  
  87.     /* see that file exists */
  88.  
  89.     if (bookmarkFilename[0] == '0') return -1;
  90.  
  91.     /* find valid directory entry */
  92.  
  93.     if ((pwdentry = getpwuid( (int) geteuid() ))  == NULL) return -1;
  94.  
  95.     /* if not an absolute path name, build path name ~/.gopherbk */
  96.  
  97.     if (bookmarkFilename[0] != '/') {
  98.         strcpy (bkmkFile, pwdentry->pw_dir);
  99.         strcat (bkmkFile, "/");
  100.         strcat (bkmkFile, bookmarkFilename);
  101.         bFD = open(bkmkFile, flags);
  102.     } else {
  103.         bFD = open(bookmarkFilename, flags);
  104.     }
  105.  
  106.     return bFD;
  107. }
  108.  
  109.  
  110. /* bkmkSave
  111.    Save the current bookmark list to the bookmark save file */
  112.  
  113. void
  114. bkmkSave()
  115. {
  116.     int        bkmkFD;
  117.     char        bkmkFile[PATH_NAME_LEN];
  118.     char        oldBkmkFile[PATH_NAME_LEN];
  119.     gopherItemP    gi;
  120.     struct passwd    *pwdentry;
  121.     char        errorMessage[MESSAGE_STRING_LEN];
  122.     
  123.     /* if secure mode, shouldn't have gotten this far */
  124.  
  125.     /* see if old file exists */
  126.     /* if not an absolute path name, build path name ~/.gopherbk */
  127.  
  128.     if (bookmarkFilename[0] != '/') {
  129.         if ((pwdentry = getpwuid( (int) geteuid() ))  == NULL) return;
  130.         strcpy (bkmkFile, pwdentry->pw_dir);
  131.         strcat (bkmkFile, "/");
  132.         strcat (bkmkFile, bookmarkFilename);
  133.     } else {
  134.         strcpy (bkmkFile, bookmarkFilename);
  135.     }
  136.  
  137.     /* build "backup" path name ~/.gopherbk~ */
  138.  
  139.     strcpy (oldBkmkFile, bkmkFile);
  140.     strcat (oldBkmkFile, OLD_SUFFIX);
  141.  
  142.     /* if file exists, rename it to backup file if possible */
  143.  
  144.     bkmkFD = open(bkmkFile, O_RDONLY);
  145.     if (bkmkFD > -1) {
  146.         close(bkmkFD);
  147.         if (rename(bkmkFile, oldBkmkFile) < 0) {
  148.             perror("rename");
  149.             sprintf(errorMessage,
  150.             "Cannot backup old bookmark file: %s to %s",
  151.             bkmkFile, oldBkmkFile);
  152.             showError(errorMessage);
  153.             return;
  154.         }
  155.     }
  156.     
  157.     /* open new file */
  158.  
  159.     bkmkFD = open (bkmkFile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  160.     if (bkmkFD < 0) {
  161.         perror("open");
  162.         sprintf(errorMessage, "Cannot save bookmarks to %s", bkmkFile);
  163.         showError(errorMessage);
  164.         return;
  165.     }
  166.     
  167.     /* write old user stuff that curses client may need */
  168.  
  169.     writeString (bkmkFD, userStuff);
  170.  
  171.     /* write bookmarks */
  172.  
  173.     gi = firstMark();
  174.     if (gi != NULL) {
  175.         writeString (bkmkFD, "bookmarks:\n");
  176.         for ( ; gi != NULL; gi = gi->next) {
  177.             char    typeString[2];
  178.             char    portString[16];
  179.  
  180.             typeString[0] = gi->type;
  181.             typeString[1] = '\0';
  182.             sprintf (portString, "%d", gi->port);
  183.  
  184.             writeString (bkmkFD, "#");
  185.             writeString (bkmkFD, "\nType=");
  186.             writeString (bkmkFD, typeString);
  187.             writeString (bkmkFD, "\nName=");
  188.             writeString (bkmkFD, USER_STRING(gi));
  189.             writeString (bkmkFD, "\nPath=");
  190.             writeString (bkmkFD, vStringValue(&(gi->selector)));
  191.             writeString (bkmkFD, "\nHost=");
  192.             writeString (bkmkFD, gi->host);
  193.             writeString (bkmkFD, "\nPort=");
  194.             writeString (bkmkFD, portString);
  195.             writeString (bkmkFD, "\n");
  196.         }
  197.     }
  198.  
  199.     close(bkmkFD);
  200. }
  201.  
  202.  
  203. #define    G_PATH    (1<<0)
  204. #define    G_TYPE  (1<<1)
  205. #define    G_NAME    (1<<2)
  206. #define    G_PORT    (1<<3)
  207. #define    G_HOST    (1<<4)
  208. #define    G_ALL (G_PATH | G_TYPE | G_NAME | G_PORT | G_HOST)
  209.  
  210. /* readSavedItem
  211.    read a gopher item descriptor from the save file.
  212.    returns pointer to a gopher item with success, NULL on an error.  */
  213.  
  214. static gopherItemP
  215. readSavedItem(fd, defaultHost, defaultPort)
  216. int    fd;
  217. char    *defaultHost;
  218. int    defaultPort;
  219. {
  220.      int    doneFlags = 0;
  221.      char    buf[1024];
  222.      char    type;
  223.      char    name[1024], path[1024], host[1024];
  224.      int    port;
  225.  
  226.      while ((doneFlags != G_ALL) && readLine(fd, buf, 1024)) {
  227.       if (buf[0] == '#')
  228.            continue;   /* comment */
  229.  
  230.       zapCRLF(buf);
  231.  
  232.       if (strncmp(buf, "Type=", 5)==0) {
  233.            type = buf[5];
  234.            doneFlags |= G_TYPE;
  235.       }
  236.       
  237.       if (strncmp(buf, "Name=", 5)==0) {
  238.            strcpy(name, buf+5);
  239.            doneFlags |= G_NAME;
  240.       }
  241.        
  242.       if (strncmp(buf, "Path=", 5)==0) {
  243.            strcpy(path, buf+5);
  244.            doneFlags |= G_PATH;
  245.       }
  246.        
  247.       if (strncmp(buf, "Host=", 5)==0) {
  248.            if (buf[5] == '+' && buf[6] == '\0')
  249.                 strcpy(host, defaultHost);
  250.            else
  251.                 strcpy(host, buf+5);
  252.  
  253.            doneFlags |= G_HOST;
  254.       }
  255.       if (strncmp(buf, "Port=", 5)==0) {
  256.            if (buf[5] == '+' && buf[6] == '\0')
  257.             port = defaultPort;
  258.            else
  259.             port = atoi(buf+5);
  260.  
  261.            doneFlags |= G_PORT;
  262.       }
  263.     }
  264.  
  265.     if (doneFlags == G_ALL) {
  266.         return (makeItem(type, name, path, host, port, FALSE));
  267.     } else {
  268.         return NULL;
  269.     }
  270. }
  271.  
  272.  
  273. /* bkmkLoad
  274.    Load a previous bookmark list from the bookmark save file */
  275.  
  276. void
  277. bkmkLoad()
  278. {
  279.     int        bkmkFD;
  280.     char        bkmkFile[PATH_NAME_LEN];
  281.     char        inputLine[FILE_LINE_LEN];
  282.     struct passwd    *pwdentry;
  283.     char        errorMessage[MESSAGE_STRING_LEN];
  284.     int        n;
  285.     gopherItemP    gi;
  286.     
  287.  
  288.     if ((bkmkFD = bkmkOpen(O_RDONLY)) < 0) return;
  289.  
  290.     *userStuff = '\0';
  291.     while ((n = readLine(bkmkFD, inputLine, sizeof(inputLine))) > 0) {
  292.  
  293.         zapCRLF(inputLine);
  294.  
  295.         if (strncasecmp(inputLine, "bookmarks:", 9) != 0) {
  296.  
  297.             /*  not a bookmark list, just stash text away */
  298.  
  299.             if ((int)(strlen(userStuff)+n+1) < USER_STUFF_LEN) {
  300.                 strcat(userStuff, inputLine);
  301.                 strcat(userStuff, "\n");
  302.             }
  303.  
  304.         } else {
  305.  
  306.             /* a bookmark list: load it */
  307.             
  308.             if (! appendBkmkList) unmarkAllItems();
  309.             do {
  310.                 gi = readSavedItem(bkmkFD, "localhost", 70);
  311.                 if (gi != NULL) markItem(gi);
  312.             } while (gi != NULL);
  313.         }
  314.     }
  315.  
  316.     close (bkmkFD);
  317. }
  318.